home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / tcpip / amiga / asrc29k.lha / digger.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-08  |  11.5 KB  |  481 lines
  1. /* Digger functions.
  2.    08/07/90, Bob Applegate wa2zzx */
  3.  
  4. #include <stdio.h>
  5. #include <ctype.h>
  6. #include <exec/types.h>
  7. #include <time.h>
  8. #include "global.h"
  9. #include "cmdparse.h"
  10. #include "commands.h"
  11. #include "proc.h"
  12. #include "files.h"
  13. #include "smtp.h"
  14. #include <dos.h>
  15. #include <ios1.h>
  16. #include <proto/dos.h>
  17. #include "bm.h"
  18. #include "ax25.h"
  19.  
  20. static int mailcat __ARGS((char *file,char *explanation));
  21. static int AddSMTPHeader __ARGS((FILE *tfile, char *explanation));
  22.  
  23. extern char *mbxtime __ARGS((char *line));
  24. extern char *Organ, *RHdr;
  25.  
  26. int DiggerLock, MaxSeg = 3000, MaxReq = 5, reqcnt = 0;
  27. extern char *Digger, *DiggerC;
  28. char whoto[80], *tonic;
  29.  
  30. static void DiggerProcess __ARGS(());
  31. static int CheckForStuff __ARGS((int argc,char *argv[],void *p));
  32. static struct proc *ProcessPointer;
  33.  
  34. extern int mlock __ARGS((char *dir,char *id));
  35. extern int rmlock __ARGS((char *dir,char *id));
  36.  
  37. static int dgstart __ARGS((int argc,char *argv[],void *p));
  38. static int dgstop __ARGS((int argc,char *argv[],void *p));
  39. static int dgkick __ARGS((int argc,char *argv[],void *p));
  40. static int dgsegsiz __ARGS((int argc,char *argv[],void *p));
  41. static int dgmaxreq __ARGS((int argc,char *argv[],void *p));
  42.  
  43. static int dgban __ARGS((int argc,char *argv[],void *p));
  44. static int dgunban __ARGS((int argc,char *argv[],void *p));
  45.  
  46. /* Digger: Banned Users */
  47. struct br {
  48.     struct br *prev;
  49.     struct br *next;
  50.     char addr[AXALEN];
  51.     int bancnt;
  52. };
  53.  
  54. struct br *Br;
  55.  
  56. static struct cmds Diggercmds[] = {
  57.    "ban",         dgban,       0, 0, NULLCHAR,
  58.    "kick",        dgkick,      0, 0, NULLCHAR,
  59.    "maxrequests", dgmaxreq,    0, 0, NULLCHAR,
  60.    "on",          dgstart,     0, 0, NULLCHAR,
  61.    "off",         dgstop,      0, 0, NULLCHAR,
  62.    "segmentsize", dgsegsiz,    0, 0, NULLCHAR,
  63.    "unban",       dgunban,     0, 0, NULLCHAR,
  64.    NULLCHAR
  65. };
  66.  
  67. int dodigger(argc,argv,p)
  68. int argc;
  69. char *argv[];
  70. void *p;
  71. {
  72.    return subcmd(Diggercmds,argc,argv,p);
  73. }
  74.  
  75. static int dgstart(argc,argv,p)
  76. int argc;
  77. char *argv[];
  78. void *p;
  79. {
  80.    ProcessPointer = newproc("Digger",1024,DiggerProcess,0,NULL,NULL);
  81.  
  82.    return 0;
  83. }
  84.  
  85. static int dgstop(argc,argv,p)
  86. int argc;
  87. char *argv[];
  88. void *p;
  89. {
  90.    killproc(ProcessPointer);
  91.  
  92.    return 0;
  93. }
  94.  
  95. static int dgkick(argc,argv,p)
  96. int argc;
  97. char *argv[];
  98. void *p;
  99. {
  100.    psignal(&DiggerLock,1);
  101.  
  102.    return 0;
  103. }
  104.  
  105. static int dgsegsiz(argc,argv,p)
  106. int argc;
  107. char *argv[];
  108. void *p;
  109. {
  110.    if(argc > 1)
  111.       MaxSeg = atoi(argv[1]);
  112.    else
  113.       tprintf("Maximum Message Segment: %d Bytes\n",MaxSeg);
  114.  
  115.    return 0;
  116. }
  117.  
  118. static int dgmaxreq(argc,argv,p)
  119. int argc;
  120. char *argv[];
  121. void *p;
  122. {
  123.    if(argc > 1)
  124.       MaxReq = atoi(argv[1]);
  125.    else
  126.       tprintf("Requests per Message: %d\n",MaxReq);
  127.  
  128.    return 0;
  129. }
  130.  
  131. static int dgban(argc,argv,p)
  132. int argc;
  133. char *argv[];
  134. void *p;
  135. {
  136.    register struct br *bp;
  137.  
  138.    if (argc < 2) {
  139.       tprintf("Banned users: ");
  140.       if(Br != NULLLQ)
  141.          for(bp = Br;bp != NULLLQ;bp = bp->next)
  142.             tprintf(" %s(%d)",bp->addr,bp->bancnt);
  143.       else
  144.          tprintf(" Empty");
  145.       tprintf("\n");
  146.    } else {
  147.       bp = (struct br *)callocw(1,sizeof(struct br));
  148.       memcpy(bp->addr,argv[1],AXALEN);
  149.       bp->bancnt = atoi(argv[2]) == 0 ? 1 : atoi(argv[2]);
  150.       bp->next = Br;
  151.       if(bp->next != NULLLQ)
  152.          bp->next->prev = bp;
  153.       Br = bp;
  154.       tprintf("Digger: '%s' Banned for %d\n",
  155.                argv[1],
  156.                atoi(argv[2]) == 0 ? 1 : atoi(argv[2]));
  157.    }
  158.  
  159.    return 0;
  160. }
  161.  
  162. static int dgunban(argc,argv,p)
  163. int argc;
  164. char *argv[];
  165. void *p;
  166. {
  167.    register struct br *bp;
  168.  
  169.    if (argc < 2) 
  170.       tprintf("string missing!\n");
  171.    else {
  172.       for(bp = Br;bp != NULLLQ;bp = bp->next)
  173.          if(strstr(argv[1],bp->addr))
  174.             break;
  175.  
  176.       if(bp == NULLLQ) {
  177.          tprintf("Not found\n");
  178.          return 1;
  179.       }
  180.  
  181.       if(bp->prev != NULLLQ)
  182.          bp->prev->next = bp->next;
  183.       else
  184.          Br = bp->next;
  185.       if(bp->next != NULLLQ)
  186.          bp->next->prev = bp->prev;
  187.  
  188.       tprintf("Digger: '%s' unbanned\n",argv[1]);
  189.    }
  190.    return 0;
  191. }
  192.  
  193. /** This is the function to handle the interface to the smtp server.
  194.  ** It waits for a resume, then processes everything on the list. */
  195. static void DiggerProcess()
  196. {
  197.    for (;;) {
  198.       pwait(&DiggerLock);   /* wait for something to do... */
  199.       CheckForStuff(NULL,NULLCHAR,NULL);   /* ...then do it */
  200.    }
  201. }
  202.  
  203. static int dgretr __ARGS((int argc,char *argv[],void *p));
  204. static int sendhelp __ARGS((int argc,char *argv[],void *p));
  205. static int sendindex __ARGS((int argc,char *argv[],void *p));
  206. static int listarchives __ARGS((int argc,char *argv[],void *p));
  207.  
  208. static struct cmds diggercmds[] =  {
  209.    "archives",  listarchives, 0, 0, NULLCHAR,
  210.    "help",      sendhelp,     0, 0, NULLCHAR,
  211.    "index",     sendindex,    0, 1, NULLCHAR,
  212.    "retrieve",  dgretr,       0, 1, NULLCHAR,
  213.    NULLCHAR
  214. };
  215.  
  216. /** This function is responsible for reading in mail sent to Digger
  217.  ** and processing the commands. */
  218. static int CheckForStuff(argc,argv,p)
  219. int argc;
  220. char *argv[];
  221. void *p;
  222. {
  223.    register struct br *bp;
  224.    char *CLine, filename[128], *cp;
  225.    int result;
  226.    FILE *fp;
  227.  
  228.    fflush(stdout);
  229.    while (mlock(Mailspool,"Digger"))   /* until we get the lock */
  230.       pause(10 * 1000 / MSPTICK);   /* wait 10 seconds */
  231.    fflush(stdout);
  232.    sprintf(filename,"%s/%s",Mailspool,"Digger.txt");
  233.    fp = fopen(filename,"r");
  234.    if (fp == NULL) {
  235.       (void) rmlock(Mailspool,"Digger");   /* remove our hold on it */
  236.       return 0;
  237.    }
  238.  
  239.    strcpy(whoto, "Postmaster");
  240.  
  241.    reqcnt = 0;
  242.    CLine = mallocw(BUFSIZ);
  243.    while (fgets(CLine,BUFSIZ,fp) != NULLCHAR) {
  244.       rip(CLine);
  245.  
  246.       if (strnicmp(CLine,"Reply-To: ",10) == 0) {
  247.          strcpy(whoto, getaddress(CLine,0));
  248.       } else if (strnicmp(CLine,"From: ",6) == 0) {
  249.          strcpy(whoto, getaddress(CLine,0));
  250.       }
  251.  
  252.       if (strnicmp(CLine,"R:",2) == 0) {
  253.          tonic = strstr(strdup(CLine),"@");
  254.          if((cp=strchr(tonic,' ')) != NULLCHAR)
  255.             *cp = '\0';
  256.       }
  257.  
  258.       for(bp = Br;bp != NULLLQ;bp = bp->next)
  259.          if(strstr(whoto, bp->addr)) {
  260.             mainlog(-1,"Digger rejected request from '%s'", whoto);
  261.             goto rejlab;
  262.          }
  263.  
  264.       if(strlen(CLine) > 0) 
  265.          if((result = cmdparse(diggercmds, CLine, p)) == 0);
  266.    }
  267. rejlab:
  268.    free(CLine);
  269.    fclose(fp);
  270.  
  271.    unlink(filename);
  272.    rmlock(Mailspool,"Digger");   /* remove our hold on it */
  273.  
  274.    return 0;
  275. }
  276.  
  277. static int dgretr(argc,argv,p)
  278. int argc;
  279. char *argv[];
  280. void *p;
  281. {
  282.    FILE *in;
  283.    char buf[100], command[100], error[100], *archive, *specific;
  284.  
  285.    specific = (argv[1] == NULLCHAR) ? NULL : argv[1];
  286.    archive = (argv[2] == NULLCHAR) ? "DataBase" : argv[2];
  287.  
  288.    mainlog(-1,"Digger: Retrieve '%s' From '%s' For '%s'",
  289.                specific, archive, whoto);
  290.  
  291.    sprintf(error,"%s/error", Digger);
  292.    if(reqcnt < MaxReq) 
  293.       if(specific != NULL) {
  294.          if(strstr(specific,"*") != NULL)
  295.             mailcat(error,"Wild Cards Not Permitted!");
  296.          else {
  297.             sprintf(buf,"%s/%s", DiggerC, specific);
  298.             if((in = fopen(buf,READ_TEXT)) != NULLFILE) {
  299.                fclose(in);
  300.                mailcat(buf,specific);
  301.             } else {
  302.                sprintf(command,"LHA >nil: -N -n -m x %s/%s %s/ %s",
  303.                     Digger, archive, DiggerC, specific);
  304.                if (!Execute(command, 0, 0)) {
  305.                   return (FILE *)NULL;
  306.                }
  307.                if((in = fopen(buf,READ_TEXT)) != NULLFILE) {
  308.                   fclose(in);
  309.                   mailcat(buf,specific);
  310.                   reqcnt++;
  311.                } else
  312.                   mailcat(error,"File Not Found!");
  313.             }
  314.          } 
  315.       } else {
  316.          sprintf(buf,"%s/retrieve",Digger);
  317.          mailcat(buf,"retrieve");
  318.          reqcnt++;
  319.       }
  320.  
  321.    return 0;
  322. }
  323.  
  324. static int sendhelp(argc,argv,p)
  325. int argc;
  326. char *argv[];
  327. void *p;
  328. {
  329.    char buf[100];
  330.  
  331.    if(reqcnt < MaxReq) {
  332.       mainlog(-1,"Digger: Help Requested By '%s'", whoto);
  333.       sprintf(buf,"%s/help",Digger);
  334.       mailcat(buf,argv[0]);
  335.       reqcnt++;
  336.    }
  337.    return 0;
  338. }
  339.  
  340. static int sendindex(argc,argv,p)
  341. int argc;
  342. char *argv[];
  343. void *p;
  344. {
  345.    char buf[100], command[100], error[100], *archive;
  346.  
  347.    archive = (argv[1] == NULLCHAR) ? "DataBase" : argv[1];
  348.  
  349.    if(reqcnt < MaxReq) 
  350.       if(strstr(archive,"*") == NULL) {
  351.          mainlog(-1,"Digger: Index '%s' For '%s'", archive, whoto);
  352.          sprintf(command, "LHA >%s/index -N l %s/%s", Digger, Digger, archive);
  353.          if (!Execute(command, 0, 0)) {
  354.             return (FILE *)NULL;
  355.          }
  356.          sprintf(buf,"%s/index", Digger);
  357.          mailcat(buf,archive);
  358.          reqcnt++;
  359.       } else {
  360.          sprintf(error,"%s/error", Digger);
  361.          mailcat(error,"Wild Cards Not Permitted!");
  362.       }
  363.  
  364.    return 0;
  365. }
  366.  
  367. static int listarchives(argc,argv,p)
  368. int argc;
  369. char *argv[];
  370. void *p;
  371. {
  372.    char buf[100];
  373.  
  374.    if(reqcnt < MaxReq) {
  375.       mainlog(-1,"Digger: Archives Requested By '%s'", whoto);
  376.       sprintf(buf,"%s/archives",Digger);
  377.       mailcat(buf,argv[0]);
  378.       reqcnt++;
  379.    }
  380.  
  381.    return 0;
  382. }
  383.  
  384. /* Given the person to mail it to, and a file name, this opens the file
  385.    and mails the contents to the specified user. */
  386. static int mailcat(file,explanation)
  387. char *file, *explanation;
  388. {
  389.    FILE *in, *out;
  390.    char fn[50], subject[50];
  391.    int data, bcount=0, partno = 1;
  392.  
  393.    in = fopen(file,"r");
  394.  
  395.    while ((data = fgetc(in)) != EOF) {
  396.       out = fopen("t:smtptemp.fil","w+");
  397.       if (in == NULL || out == NULL) return -1;
  398.       sprintf(subject,"%s - %d",explanation,partno);
  399.       AddSMTPHeader(out,subject);
  400.       if((bcount%MaxSeg == 0) && (bcount != 0))
  401.      fprintf(out,"[Continued from Part %d]\n\n",partno - 1);
  402.       fputc(data,out);
  403.       bcount++;
  404.       while (((data = fgetc(in)) != EOF) && (bcount%MaxSeg != 0)) {
  405.          fputc(data,out);
  406.          bcount++;
  407.       }
  408.       if(bcount%MaxSeg == 0) {
  409.          fputc(data,out);
  410.          partno++;
  411.          fprintf(out,"\n\n[Continued in Part %d]\n",partno);
  412.       }
  413.       rewind(out);
  414.  
  415.       sprintf(fn,"Digger@%s",Hostname);
  416.       mailuser(out,fn,whoto);
  417.  
  418.       fclose(out);
  419.       unlink("t:smtptemp.fil");
  420.    }
  421.    fclose(in);
  422.  
  423.    return 0;
  424. }
  425.  
  426. /* Given an open file pointer, this tacks on the proper SMTP header. */
  427. static int AddSMTPHeader(tfile,explanation)
  428. FILE *tfile;
  429. char *explanation;
  430. {
  431.    time_t t;
  432.    char buf[AXALEN], *mynic, *cp, *cp2, newto[80];
  433.    int32 id;
  434.  
  435.    if (tfile != NULLFILE) {
  436.  
  437.       pax25(buf,Mycall);
  438.       if((cp=strchr(buf,'-')) != NULLCHAR)
  439.          *cp = '\0';
  440.  
  441.       if (RHdr != NULLCHAR) {
  442.          mynic = strdup(RHdr);
  443.          if((cp2=strchr(mynic,' ')) != NULLCHAR)
  444.             *cp2 = '\0';
  445.       }
  446.     
  447.       time(&t);
  448.       id = get_msgid();
  449.  
  450.       fprintf(tfile,"%s%s",Hdrs[DATE],ptime(&t));
  451.       fprintf(tfile,"%s<%ld@%s>\n",Hdrs[MSGID], id, Hostname);
  452.  
  453.       fprintf(tfile,"%s%s@%s (%s)\n", Hdrs[FROM],
  454.          strlen(buf) ? buf : "Digger",
  455.          strlen(buf) ? (strlen(mynic) ? mynic : Hostname) : Hostname,
  456.          strlen(buf) ? "Digger" : "File Server");
  457.  
  458.       if (Organ != NULLCHAR)
  459.          fprintf(tfile,"%s%s\n",Hdrs[ORGANISATION],Organ);
  460.  
  461.       if(strstr(whoto,".bbs")) {
  462.          if((cp2=strchr(whoto,'%')) != NULLCHAR)
  463.             *cp2 = '\0';
  464.          if((cp2=strchr(tonic,':')) != NULLCHAR)
  465.             cp2 = &tonic[2];
  466.          else
  467.             cp2 = &tonic[1];
  468.          sprintf(newto, "%s@%s", whoto, cp2);
  469.          fprintf(tfile,"To: %s\n",newto);
  470.       } else
  471.          fprintf(tfile,"To: %s\n",whoto);
  472.  
  473.       fprintf(tfile,"%sRe: '%s'\n", Hdrs[SUBJECT], explanation);
  474.       fprintf(tfile,"%sAmigaNOS v%s\n",Hdrs[COMMENT],Version);
  475.       fprintf(tfile,"\n");
  476.       if (RHdr != NULLCHAR)
  477.          fprintf(tfile,"R:%s @:%s #:%ld\n\n",
  478.                  mbxtime(ptime(&t)), RHdr, id);
  479.    } else return -1;
  480. }
  481.